package ClassesAndObjects;

//目前学习的static的三种用法：
//1.static修饰成员变量：static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。
//2.static修饰成员方法：被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。
//3.static成员变量初始化：分就地初始化 和 静态代码块初始化，就地初始化指的是：在定义时直接给出初始值

//目前学习了3中变量：
//1.局部变量：方法内部定义的变量
//2.静态成员变量：在类的里面，方法的外面，被static修饰的
//3.普通成员变量：在类的里面，方法的外面

//成员变量在没有初始化时都有一个默认值：char:’\u0000‘; double:0.0; float:0.0f; int:0; boolean:false;
//成员变量在使用时可以不初始化，但是局部变量在使用时必须初始化
class Student {
    //我想隐藏我的实现细节，不想让类的外部看到我的细节--使用封装！！！
    //封装在java中，语法层次上面来看，就是使用关键字private来实现就可以了(把类的实现细节进行了隐藏，类的外面看不到这个数据)
    //被private修饰的属性，只能在当前类当中使用
    //访问修饰限定符：public private 什么都不写，就有一个默认的权限 protected
//    public String name;
//    public int age;

    private String name;//普通成员变量
    private int age;
    //在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员/类变量，其不属于某个具体的对
    //象，是所有对象所共享的。这样教室就在方法去当中的内存中了且只有一份
    public static String classRoom = "301";//静态的就地初始化



//    public String name = ”悟空“;//就地初始化（不太好，意义不大，因为不可能每一个对象的姓名都叫悟空），后面还要初始化一次
//    public int age = 12;

    public Student() {
//        this.name = "yxj";
//        this.age = 12;

        //1.this只能在构造方法里面调用构造方法
        //2.构造方法不能自己调用自己
        //3.被调用的构造方法只能放在构造方法的第一行
        //目前学过的this的三种用法：1.this.属性；2.this()  -->调用构造方法 ；3.this.方法
        //this("yxj",12);
        System.out.println("调用了不带参数的构造方法 ！");
    }

    public Student(String name, int age) {
        //构造方法不能自己调用自己
        // this("yxj",12);
        this.name = name;
        this.age = age;
        System.out.println("调用了带2个参数的构造方法！");
    }

//    public Student(String name, int age, String classRoom) {
//        this.name = name;
//        this.age = age;
//        this.classRoom = classRoom;
//    }

    //idea快捷设置set和get:代码行右键->Generate->选择getter和setter
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return this.name;
    }
    public int getAge() {
        return this.age;
    }

    public void doClass() {
        System.out.println(this.name + "上课！");
    }
    public void print() {
        System.out.println("姓名：" +this.name + " 年龄：" + this.age );
    }
    //静态成员方法/类方法：不依赖对象
    public static void funStatic() {
        //通过对象的引用来调用，说明print是依赖对象的，在静态方法中，都没有生成对象，所以报错
        //静态方法内部是不能掉头非静态方法的
        //print();
        System.out.println("静态成员方法：funcStatic");
    }
}


public class Test1 {
    public static void main(String[] args) {
        Student.funStatic();
    }


    public static void main4(String[] args) {
        Student student1 = new Student("zhangsan",10);
        Student student2 = new Student("lisi",20);
        Student student3 = new Student("wangwu",3);

        //静态成员的访问方式：不建议通过对象的引用来访问（因为此时的classRoom不是属于对象的）；建议通过类名.的当时进行访问
//        System.out.println("教室是："+student1.classRoom);
//        System.out.println("教室是："+student2.classRoom);
//        System.out.println("教室是："+student3.classRoom);
        //类的静态成员变量时用类名来访问的，也就是说，这个静态成员变量不属于对象！！生命周期伴随类的一生
        System.out.println("教室是："+Student.classRoom);

    }


    public static void main3(String[] args) {
        Student student1 = new Student();
//        student1.name = "张三";
//        student1.age = 18;
        //“java中 当定义了一个私有的成员变量的时候，如果需要访问或者获取这个变量的时候，就可以编写set或者get方法去调用，
        // set是给属性赋值的，get是取得属性值的，被设置和存取的属性一般是私有主要是起到封装作用不允许直接对属性进行操作。
        student1.setName("zhangsan");
        student1.setAge(18);
        System.out.println(student1.getName());
        System.out.println(student1.getAge());
        student1.print();
    }


    public static void main2(String[] args) {
        Student student1 = new Student();
        student1.print();

        Student student2 = null; //此时student2不指向任何对象
    }


    public static void main1(String[] args) {
        Student student1 = new Student();
//        student1.name = "张三";
//        student1.age = 18;
        student1.doClass();

        Student student2 = new Student("lisi",18);
        student2.print();
    }
}
